/*
 * @Author: Await
 * @Date: 2025-05-09 11:30:00
 * @LastEditors: Await
 * @LastEditTime: 2025-05-09 19:10:00
 * @Description: 图表配置处理Hook
 */

import { useState, useEffect, useRef } from 'react';
import { UseChartConfigParams } from './types';
import { ChartType, ChartConfig } from '../../../types/chartTypes';
import { transformDataToOption } from '../../../utils/chart/dataTransformers';
import { process3DChartConfig, is3DChartType } from '../../../utils/chart/3dChartUtils';
import { registerTheme } from '../../../utils/chart/themeUtils';
import { cloneDeep } from 'lodash';
import { logDebug, logWarning } from '../../../utils/chart/commonUtils';

/**
 * 扩展配置类型，添加_originalType字段
 */
type ExtendedConfig = {
    _originalType?: string;
    textStyle?: any;
    series?: any[];
    radar?: any;
    type?: string;
    [key: string]: any;
};

/**
 * 雷达图独有的配置
 */
interface RadarConfig {
    indicator: Array<{
        name: string;
        max?: number;
    }>;
    shape?: string;
    center?: [string, string];
    radius?: string | number;
    [key: string]: any;
}

/**
 * 确保配置的完整性
 * 添加必要的默认设置
 * @param config 图表配置
 * @param isRadar 是否是雷达图
 */
const ensureConfigCompleteness = (config: ExtendedConfig, isRadar = false): ExtendedConfig => {
    if (!config) return config;

    // 克隆配置以避免修改原始对象
    const result: ExtendedConfig = { ...config };

    // 确保2D图表有正确的grid配置
    if (!is3DChartType(config.type) && !result.grid && !isRadar) {
        result.grid = {
            containLabel: true,
            left: '3%',
            right: '4%',
            bottom: '3%',
            top: '3%'
        };
    }

    // 确保有tooltip配置
    if (!result.tooltip) {
        result.tooltip = {
            trigger: isRadar ? 'item' : 'axis'
        };
    }

    // 如果是雷达图，确保有正确的radar配置
    if (isRadar && !result.radar) {
        result.radar = {
            indicator: [], // 使用空数组，不使用模拟指标数据
            shape: 'polygon',
            center: ['50%', '50%'],
            radius: '75%'
        };
    }

    return result;
};

/**
 * 图表配置处理Hook
 * 处理数据和配置的转换，应用主题等
 */
const useChartConfig = ({
    option,
    data,
    dataConfig,
    animation = true,
    theme
}: UseChartConfigParams) => {
    // 最终处理后的配置
    const [finalConfig, setFinalConfig] = useState<ExtendedConfig | null>(null);

    // 添加一个状态，用于跟踪第一次渲染
    const [isFirstRender, setIsFirstRender] = useState<boolean>(true);

    // 是否是3D图表
    const [is3DChart, setIs3DChart] = useState<boolean>(false);

    // 跟踪前一个图表类型
    const previousTypeRef = useRef<string | undefined>(undefined);

    // 上一次的处理结果，避免重复计算
    const lastFinalConfigRef = useRef(null);

    // 处理图表配置
    useEffect(() => {
        if (!option) {
            // 如果没有配置，设置为null
            setFinalConfig(null);
            return;
        }

        // 记录开始处理时间，便于性能分析
        const startTime = performance.now();

        try {
            // 转换为扩展配置类型
            const extendedOption = option as ExtendedConfig;

            // 获取配置类型
            const configType = extendedOption.type ||
                (extendedOption.series &&
                    Array.isArray(extendedOption.series) &&
                    extendedOption.series.length > 0 &&
                    extendedOption.series[0]?.type) ||
                extendedOption._originalType;

            // 首先，确定配置中明确设置的类型
            const explicitType = extendedOption.type || configType;

            // 简化雷达图检测 - 只有明确类型为'radar'时才识别为雷达图
            const isRadarConfig: boolean = explicitType === 'radar';

            console.log('雷达图检测:', {
                explicitType,
                isRadarConfig,
                hasRadar: !!extendedOption.radar,
                seriesType: extendedOption.series &&
                    Array.isArray(extendedOption.series) &&
                    extendedOption.series.length > 0 ?
                    extendedOption.series[0]?.type : 'none'
            });

            // 对于任何非雷达图类型，总是彻底清理所有雷达图配置
            if (!isRadarConfig) {
                console.log('useChartConfig检测到非雷达图类型:', explicitType, '强制清理所有雷达图配置');

                // 始终删除radar属性
                if (extendedOption.radar) {
                    console.log('useChartConfig删除radar属性');
                    delete extendedOption.radar;
                }

                // 总是修正series类型
                if (extendedOption.series && Array.isArray(extendedOption.series)) {
                    extendedOption.series.forEach((series, index) => {
                        if (!series) return;
                        if (series.type === 'radar') {
                            console.log(`useChartConfig修正series[${index}].type从radar到${explicitType || 'bar'}`);
                            series.type = explicitType || 'bar';
                        }
                    });
                }

                // 总是删除_originalType
                if (extendedOption._originalType) {
                    console.log('useChartConfig删除_originalType:', extendedOption._originalType);
                    delete extendedOption._originalType;
                }
            }

            if (isRadarConfig) {
                console.log('useChartConfig: 检测到雷达图配置');

                // 当从其他图表类型切换到雷达图时，完全重置配置
                if (configType === 'radar' && previousTypeRef.current !== 'radar') {
                    console.log('useChartConfig: 从其他图表切换到雷达图，创建全新配置');

                    // 创建全新的雷达图配置
                    const radarConfig: ExtendedConfig = {
                        // 基础配置
                        title: extendedOption.title,
                        tooltip: {
                            trigger: 'item',
                            ...(extendedOption.tooltip || {})
                        },
                        legend: extendedOption.legend,
                        // 主题相关
                        backgroundColor: extendedOption.backgroundColor,
                        color: extendedOption.color,
                        textStyle: extendedOption.textStyle,
                        theme: extendedOption.theme,

                        // 雷达图特有配置
                        radar: extendedOption.radar || {
                            indicator: [], // 不使用默认指标，使用空数组
                            shape: 'polygon',
                            center: ['50%', '50%'],
                            radius: '75%'
                        },

                        // 雷达图系列配置，初始化为空数组
                        series: [],

                        // 记录原始类型
                        _originalType: 'radar'
                    };

                    // 处理系列数据
                    if (extendedOption.series && Array.isArray(extendedOption.series)) {
                        radarConfig.series = extendedOption.series.map((series: any) => {
                            // 确保数据格式正确
                            const formattedData = Array.isArray(series.data) ?
                                series.data.map((item: any) => {
                                    if (typeof item === 'object' && item !== null && !Array.isArray(item)) {
                                        return {
                                            name: item.name || '',
                                            value: Array.isArray(item.value) ? item.value.map((v: any) => v === null ? 0 : v) : [0, 0, 0, 0, 0] // 使用0代替null
                                        };
                                    } else if (Array.isArray(item)) {
                                        return {
                                            name: '',
                                            value: item.map((v: any) => v === null ? 0 : v) // 使用0代替null
                                        };
                                    } else {
                                        return {
                                            name: '',
                                            value: [] // 使用空数组
                                        };
                                    }
                                }) :
                                []; // 使用空数组，不使用模拟数据

                            // 返回雷达图系列配置
                            return {
                                type: 'radar',
                                name: series.name || '系列',
                                data: formattedData,
                                // 保留样式配置
                                itemStyle: series.itemStyle,
                                lineStyle: series.lineStyle || { width: 2 },
                                areaStyle: series.areaStyle || { opacity: 0.3 }
                            };
                        });
                    } else {
                        // 如果没有系列，创建默认系列
                        radarConfig.series = [{
                            type: 'radar',
                            name: '系列1',
                            data: [], // 使用空数组而不是模拟数据
                            itemStyle: {},
                            lineStyle: { width: 2 },
                            areaStyle: { opacity: 0.3 }
                        }];
                    }

                    // 移除干扰属性
                    if ('xAxis' in radarConfig) delete radarConfig.xAxis;
                    if ('yAxis' in radarConfig) delete radarConfig.yAxis;
                    if ('grid' in radarConfig) delete radarConfig.grid;

                    // 更新为最终配置
                    setFinalConfig(radarConfig);

                    // 记录完成时间和结果
                    const endTime = performance.now();
                    console.log(`雷达图配置处理耗时: ${(endTime - startTime).toFixed(2)}ms`);

                    // 提前返回，避免执行后续代码
                    return;
                }

                // 更新上一个类型
                previousTypeRef.current = 'radar';
            } else {
                // 更新上一个类型（非雷达图）
                previousTypeRef.current = configType;
            }

            // 1. 转换数据到选项
            let config: ExtendedConfig = data && dataConfig
                ? transformDataToOption(option as any, data, dataConfig)
                : { ...extendedOption };

            // 2. 处理动画设置
            if (!animation) {
                config = {
                    ...config,
                    animation: false,
                    animationThreshold: 0
                };
            }

            // 3. 检查是否为3D图表，应用3D特定处理
            const is3D = is3DChartType(config.type || '');
            setIs3DChart(is3D);

            if (is3D) {
                // 直接使用从3dChartUtils导入的函数
                config = process3DChartConfig(config);
            }

            // 4. 应用主题样式（如果有）
            // 主题已通过 registerTheme 函数处理，无需额外处理

            // 5. 确保配置的完整性 - 对于雷达图，传入特殊标记
            config = ensureConfigCompleteness(config, !!isRadarConfig);

            // 6. 特殊类型处理 - 对雷达图进行特殊处理，确保正确的series配置
            // 如果是雷达图，则进行雷达图的特殊处理
            if (isRadarConfig) {
                console.log('处理雷达图特殊配置');

                // 确保雷达图有正确的series配置
                if (!config.series || !Array.isArray(config.series) || config.series.length === 0) {
                    config.series = [{
                        type: 'radar',
                        data: [] // 使用空数组
                    }];
                } else {
                    // 确保每个series都有正确的类型
                    config.series = config.series.map(series => ({
                        ...series,
                        type: 'radar'
                    }));
                }

                // 雷达图必须有radar配置
                if (!config.radar) {
                    config.radar = {
                        indicator: [] // 使用空数组
                    };
                }

                // 确保雷达图数据结构正确
                if (config.series && Array.isArray(config.series)) {
                    config.series = config.series.map(series => {
                        // 确保数据是雷达图格式
                        if (!series.data || !Array.isArray(series.data) || series.data.length === 0) {
                            return {
                                ...series,
                                data: [] // 使用空数组而不是模拟数据
                            };
                        }

                        // 确保每个数据项都有正确的格式
                        const newData = series.data.map((item: any) => {
                            if (typeof item !== 'object' || !item) {
                                return {
                                    name: '',
                                    value: []
                                };
                            }

                            // 如果没有value或不是数组，创建合适的数据结构
                            if (!item.value || !Array.isArray(item.value)) {
                                const indicatorCount = config.radar?.indicator?.length || 0;
                                return {
                                    name: item.name || '',
                                    value: []
                                };
                            }

                            // 确保value数组中没有null值
                            if (Array.isArray(item.value)) {
                                return {
                                    ...item,
                                    value: item.value.map((v: any) => v === null ? 0 : v) // 使用0代替null
                                };
                            }

                            return item;
                        });

                        return {
                            ...series,
                            data: newData
                        };
                    });
                }

                // 重要：强制删除顶层type属性，避免与series[0].type冲突
                // 这是解决雷达图渲染问题的关键
                if (config.type !== undefined) {
                    delete config.type;
                }
                // 记录原始类型以便后续参考
                config._originalType = 'radar';

                // 记录雷达图的特征，用于后续验证
                const hasRadar = !!config.radar;
                const hasType = !!config.type;
                const hasSeries = config.series && Array.isArray(config.series) && config.series.length > 0;
                const seriesType = hasSeries ? config.series[0].type : null;

                console.log('雷达图特殊配置处理完成:', {
                    hasRadar,
                    hasType,
                    hasSeries,
                    seriesType
                });
            }

            // 7. 处理坐标轴配置 - 将自定义axis结构转换为ECharts标准结构
            if (!isRadarConfig && config.axis) {
                console.log('处理坐标轴配置转换');

                // 初始化xAxis和yAxis对象，如果不存在的话
                if (!config.xAxis) {
                    config.xAxis = { type: 'category' };
                } else if (typeof config.xAxis === 'object' && !Array.isArray(config.xAxis)) {
                    // 保留已有配置
                } else {
                    // 如果是数组或其他格式，转为对象
                    config.xAxis = { type: 'category' };
                }

                if (!config.yAxis) {
                    config.yAxis = { type: 'value' };
                } else if (typeof config.yAxis === 'object' && !Array.isArray(config.yAxis)) {
                    // 保留已有配置
                } else {
                    // 如果是数组或其他格式，转为对象
                    config.yAxis = { type: 'value' };
                }

                const { axis } = config;

                // 转换xAxis配置
                if (axis.xAxisLabel) {
                    config.xAxis.axisLabel = { ...axis.xAxisLabel };
                    console.log('应用X轴标签配置:', config.xAxis.axisLabel);
                }

                if (axis.xAxisLine) {
                    config.xAxis.axisLine = { ...axis.xAxisLine };
                }

                if (axis.xAxisTick) {
                    config.xAxis.axisTick = { ...axis.xAxisTick };
                }

                if (axis.xSplitLine) {
                    config.xAxis.splitLine = { ...axis.xSplitLine };
                }

                if (axis.xAxisName) {
                    // 修改：根据show属性决定是否设置name
                    if (axis.xAxisName.show) {
                        // 只有当show为true时才设置name属性
                        config.xAxis.name = axis.xAxisName.text || '';
                        config.xAxis.nameLocation = axis.xAxisName.location || 'middle';
                        config.xAxis.nameTextStyle = axis.xAxisName.textStyle || {};
                        console.log('应用X轴名称配置:', axis.xAxisName);
                    } else {
                        // 如果show为false，确保name属性为空
                        config.xAxis.name = '';
                        console.log('X轴名称已隐藏');
                    }
                }

                if (axis.xAxisGeneral) {
                    // 修改：改进高级设置的处理逻辑
                    // 原代码：只在config.xAxis[key] === undefined时应用设置
                    // 但这样会导致很多设置无法覆盖默认值

                    // 直接应用所有高级设置，确保优先级高于默认设置
                    Object.keys(axis.xAxisGeneral).forEach(key => {
                        // 避免覆盖标签、轴线、刻度和分隔线的详细配置
                        if (!['axisLabel', 'axisLine', 'axisTick', 'splitLine'].includes(key)) {
                            config.xAxis[key] = axis.xAxisGeneral[key];
                            // 对于一些关键属性，添加日志
                            if (['type', 'position', 'inverse', 'scale', 'min', 'max'].includes(key)) {
                                console.log(`应用X轴高级设置 ${key}:`, axis.xAxisGeneral[key]);
                            }
                        }
                    });
                    console.log('应用X轴高级配置完成');
                }

                // 转换yAxis配置
                if (axis.yAxisLabel) {
                    config.yAxis.axisLabel = { ...axis.yAxisLabel };
                    console.log('应用Y轴标签配置:', config.yAxis.axisLabel);
                }

                if (axis.yAxisLine) {
                    config.yAxis.axisLine = { ...axis.yAxisLine };
                }

                if (axis.yAxisTick) {
                    config.yAxis.axisTick = { ...axis.yAxisTick };
                }

                if (axis.ySplitLine) {
                    config.yAxis.splitLine = { ...axis.ySplitLine };
                }

                if (axis.yAxisName) {
                    // 修改：根据show属性决定是否设置name
                    if (axis.yAxisName.show) {
                        // 只有当show为true时才设置name属性
                        config.yAxis.name = axis.yAxisName.text || '';
                        config.yAxis.nameLocation = axis.yAxisName.location || 'middle';
                        config.yAxis.nameTextStyle = axis.yAxisName.textStyle || {};
                        console.log('应用Y轴名称配置:', axis.yAxisName);
                    } else {
                        // 如果show为false，确保name属性为空
                        config.yAxis.name = '';
                        console.log('Y轴名称已隐藏');
                    }
                }

                if (axis.yAxisGeneral) {
                    // 修改：改进高级设置的处理逻辑
                    // 原代码：只在config.yAxis[key] === undefined时应用设置
                    // 但这样会导致很多设置无法覆盖默认值

                    // 直接应用所有高级设置，确保优先级高于默认设置
                    Object.keys(axis.yAxisGeneral).forEach(key => {
                        // 避免覆盖标签、轴线、刻度和分隔线的详细配置
                        if (!['axisLabel', 'axisLine', 'axisTick', 'splitLine'].includes(key)) {
                            config.yAxis[key] = axis.yAxisGeneral[key];
                            // 对于一些关键属性，添加日志
                            if (['type', 'position', 'inverse', 'scale', 'min', 'max'].includes(key)) {
                                console.log(`应用Y轴高级设置 ${key}:`, axis.yAxisGeneral[key]);
                            }
                        }
                    });
                    console.log('应用Y轴高级配置完成');
                }
            }

            // 最后一次检查，确保雷达图的顶层type已被删除
            if (isRadarConfig && config.type !== undefined) {
                console.log('最终删除雷达图顶层type属性:', config.type);
                delete config.type;
            }

            // 记录处理耗时
            const endTime = performance.now();
            console.log(`配置处理耗时: ${(endTime - startTime).toFixed(2)}ms`);

            // 比较当前配置和上次配置，避免不必要的状态更新
            const configStr = JSON.stringify(config);
            const lastConfigStr = lastFinalConfigRef.current ? JSON.stringify(lastFinalConfigRef.current) : null;

            if (configStr !== lastConfigStr) {
                // 更新引用
                lastFinalConfigRef.current = config;

                // 使用setTimeout异步更新状态，让当前事件循环执行完毕
                // 这样可以减少在同一帧多次触发渲染
                setTimeout(() => {
                    // 再次检查，确保在setTimeout执行时配置仍然有效
                    if (JSON.stringify(config) === configStr) {
                        // 更新最终配置
                        setFinalConfig(config);
                        console.log('配置已变化，更新状态');
                    }
                }, 0);
            } else {
                console.log('配置未变化，跳过状态更新');
            }

            // 如果是第一次渲染，更新标志
            if (isFirstRender) {
                console.log('useChartConfig: 第一次渲染完成，图表配置已准备就绪');
                setIsFirstRender(false);
            }
        } catch (error) {
            console.error('处理图表配置时出错:', error);

            // 保持原始配置
            setFinalConfig(option as ExtendedConfig);

            // 即使出错，也更新第一次渲染标志
            if (isFirstRender) {
                setIsFirstRender(false);
            }
        }
    }, [option, data, dataConfig, animation, theme]);

    // 返回最终的配置和状态
    return {
        finalConfig, // 最终处理后的图表配置
        isConfigReady: finalConfig !== null, // 配置是否已经准备就绪
        is3DChart, // 是否为3D图表类型
        isFirstRender // 是否为第一次渲染
    };
};

export default useChartConfig;